<!doctype html>
<html> 
<head> 
<meta charset="utf-8">
<title>Express - NodeJS web开发框架</title> 
<link rel="stylesheet" type="text/css" href="../css/style.css"/>
<link rel="stylesheet" type="text/css" href="../css/main.css"/>
</head> 
<body> 
<ul id="toc"> 
	<li><a href="#installation">安装</a></li> 
	<li><a href="#creating-a server">创建服务器</a></li> 
	<li><a href="#creating-an https server">创建HTTPS服务器</a></li> 
	<li><a href="#configuration">配置</a></li> 
	<li><a href="#settings">设置</a></li> 
	<li><a href="#routing">路由</a></li> 
	<li><a href="#passing-route control">路由控制</a></li> 
	<li><a href="#middleware">中间件</a></li> 
	<li><a href="#route-middleware">路由中间件</a></li> 
	<li><a href="#http-methods">HTTP方法</a></li> 
	<li><a href="#error-handling">错误处理</a></li> 
	<li><a href="#route-param pre-conditions">路由参数预处理</a></li> 
	<li><a href="#view-rendering">视图渲染</a></li> 
	<li><a href="#view-partials">局部视图</a></li> 
	<li><a href="#view-lookup">视图查找</a></li> 
	<li><a href="#template-engines">模板引擎</a></li> 
	<li><a href="#session-support">Session支持</a></li> 
    <li><a href="javascript:history.go(-1);">返回</a></li> 
</ul> 
<div id="wrapper"> 
	<div id="container">
		
		
		<div id="copyright">
			<h1 style="margin-top:0;">Express JS 中文入门指引手册</h1>
			<p id="tagline"><a href="http://expressjs.com" target="_blank">Express</a> 是基于<a href="http://nodejs.org" target="_blank">Node.js</a>，高性能、一流的web开发框架。
			<br><a href="http://www.csser.com" target="_blank">CSSer.com</a> 关注Web前端及相关技术。CSSer 是国内较早关注及分享NodeJS及相关新技术的网站之一，由于新技术中文资料少，CSSer希望可以通过翻译及其它方式为NodeJS在国内的推动贡献微薄之力。
			<br><br>翻译：<a href="http://www.csser.com" target="_blank" title="CSSer, 关注Web前端技术">一回</a>
			<br>日期：2011-4-24
			<br>反馈：xianlihua$gmail.com [$ -&gt; @]
			<br>特别鸣谢：<a href="http://www.csser.com" target="_blank" title="CSSer，关注Web前端技术">CSSer</a>
			<br><br> 本手册可自由转载，但须注明译者及来源，尊重他人劳动，共建和谐的学习与研究氛围，从你我做起。
			<br><br> 
			</p>
		</div>
		<h3 id="installation">安装</h3> 

<pre><code>$ npm install express
</code></pre> 

		<h3 id="creating-a server">创建服务器</h3> 

		<p>要创建<em>express.HTTPServer</em>的实例，只需简单的调用<em>createServer()</em>方法即可。通过<em>HTTPServer</em>实例<em>app</em>我们可以定义基于HTTP动作（HTTP verbs）的路由（routes），本例中为<em>app.get()</em>。</p>

<pre><code>
var app = require('express').createServer();

app.get('/', function(req, res){
  res.send('hello world from csser.com!');
});

app.listen(3000);
</code></pre> 

		<h3 id="creating-an https server">创建HTTPS服务器</h3> 

		<p>要初始化一个<em>express.HTTPSServer</em>实例，与上例相似，不同的是在<em>createServer</em>方法我们传入一个对象作为配置参数，该对象接受 <em>key</em>， <em>cert</em> 和其它在<a href="http://nodejs.org/docs/v0.4.6/api/https.html#https.createServer" target="_blank">NodeJS https文档</a>中提到的配置参数。</p> 

<pre><code> var app = require('express').createServer({ key: ... });
</code></pre> 

		<h3 id="configuration">配置</h3> 

		<p>Express支持多工作环境，比如<em>生产环境</em>和<em>开发环境</em>等。开发者可以使用<em>configure()</em>方法根据当前环境的需要进行设置，当<em>configure()</em>没有传入环境名称时，它会在各环境之前被调用（一回注：相当于被各个明确环境所共享）。</p>

<p>下面的示例我们只抛出异常（<em>dumpException</em>），并且在<em>开发模式</em>对异常堆栈的输出做出响应，但是不论对开发或者生产环境我们都使用了<em>methodOverride</em>和<em>bodyParser</em>。特别注意对<em>app.router</em>的使用，它可以被用来设置应用的<em>路由</em>（可选），否则首次对<em>app.get()</em>、<em>app.post()</em>等的调用会设置路由。</p>


<pre><code>
// 定义共享环境
app.configure(function(){
    app.use(express.methodOverride());
    app.use(express.bodyParser());
    app.use(app.router);
});

// 定义开发环境
app.configure('development', function(){
    app.use(express.static(__dirname + '/public'));
    app.use(express.errorHandler({ dumpExceptions: true, showStack: true }));
});

// 定义生产环境
app.configure('production', function(){
    var oneYear = 31557600000;
    app.use(express.static(__dirname + '/public', { maxAge: oneYear }));
    app.use(express.errorHandler());
});
</code></pre> 

		<p>对于内部和多重设置（internal和arbitrary），Express提供了 <em>set(key[, val])</em>, <em>enable(key)</em>, <em>disable(key)</em>等方法：</p>

<pre><code>
app.configure(function(){
   app.set('views', __dirname + '/views');
   app.set('views');
   // => "/absolute/path/to/views"

   app.enable('some feature');
   // 与 app.set('some feature', true); 相同

   app.disable('some feature');
   // 与 app.set('some feature', false); 相同

   app.enabled('some feature')
   // => false
});
</code></pre> 

		<p>要修改环境，可以通过设置<em>NODE_ENV</em>环境变量来实现，例如：</p>

<pre><code>$ NODE_ENV=production node app.js
</code></pre> 

		<p>这很<em>重要</em>，因为许多的缓存机制只有在生产环境<em>才会启用</em>。</p>

		<h3 id="settings">设置</h3> 

		<p>Express 支持以下设置项：</p> 

		<ul> 
			<li><em>home</em> 为<em>res.redirect()</em>提供应用的基准路径，透明的处理已安装的应用。</li> 
			<li><em>views</em> 视图（views）层的根目录，默认指向<em>CWD/views</em></li> 
			<li><em>view engine</em> 默认的视图（view）引擎的名字，不包含扩展名。</li> 
			<li><em>view options</em> 用于设置全局视图选项的对象</li> 
		</ul>


		<h3 id="routing">路由</h3> 

		<p>Express利用HTTP动作提供了有意义并富有表现力的URL映射API，例如我们可能想让用户帐号的URL看起来像<em>/user/12</em>的样子，下面的例子就能实现这样的路由，其中与占位标识符（本例为:id）相关的值可以被<em>req.params</em>获取到。
</p>

<pre><code>app.get('/user/:id', function(req, res){
    res.send('user ' + req.params.id);
});
</code></pre> 

		<p>上例中当我们访问<em>/user/12</em>时返回“user 12”,CSSer注：app.get相当于在服务器注册了一个监听get请求事件的侦听器，当请求的URL满足第一个参数时，执行后面的回调函数，该过程是异步的。</p> 
		<p>路由是一个可以被内部<em>编译</em>成<em>正则表达式</em>的简单字符串，比如当<em>/user/:id</em>被编译后，被内部编译后的正则表达式字符串看起来会是下面的样子（简化后）：</p>

<pre><code>\/user\/([^\/]+)\/?
</code></pre> 

		<p>要实现复杂点的，我们可以传入正则表达式直接量，因为正则捕获组是匿名的因此我们可以通过<em>req.params</em>进行访问，第一个捕获组应该是<em>req.params[0]</em>，第二个应该是<em>req.params[1]</em>，以此类推。</p> 

<pre><code>app.get(/^\/users?(?:\/(\d+)(?:\.\.(\d+))?)?/, function(req, res){
    res.send(req.params);
});
</code></pre> 

		<p>通过Linux的curl命令来测试我们定义的路由：</p> 

<pre><code>
$ curl http://cssercom:3000/user
[null,null]
$ curl http://cssercom:3000/users
[null,null]
$ curl http://cssercom:3000/users/1
["1",null]
$ curl http://cssercom:3000/users/1..15
["1","15"]
</code></pre> 

		<p>下面是一些路由例子，以及与之相匹配的关联路径：</p> 

<pre><code> "/user/:id"
/user/12

"/users/:id?"
/users/5
/users

"/files/*"
/files/jquery.js
/files/javascripts/jquery.js

"/file/*.*"
/files/jquery.js
/files/javascripts/jquery.js

"/user/:id/:operation?"
/user/1
/user/1/edit

"/products.:format"
/products.json
/products.xml

"/products.:format?"
/products.json
/products.xml
/products

"/user/:id.:format?"
/user/12
/user/12.json
</code></pre> 

		<p>另外，我们可以通过<em>POST</em>方式提交json数据，然后利用<em>bodyParser</em>中间件解析json请求体并把json数据返回给客户端：</p> 

<pre><code>
var express = require('express')
  , app = express.createServer();

app.use(express.bodyParser());

app.post('/', function(req, res){
  res.send(req.body);
});

app.listen(3000);
</code></pre> 

		<p>通常我们所使用的占位符（比如/user/:id）都没有任何限制，即用户可以传入各种各样数据类型的id值，如果我们希望限制用户id为数字，可以这样写<em>“/user/:id(\d+)”</em>，这样就能保证只有该占位符数据类型为数值类型才会进行路由的相关处理。</p>

		<h3 id="passing-route control">路由控制</h3> 

		<p>一个应用中可以定义多个路由，我们可以控制以令其转向下一个路由，Express提供了第<em>三</em>个参数即<em>next()</em>函数。当一个模式不被匹配时，控制将被转回Connect（Express基于Connect模块），同时中间件会继续按照它们在<em>use()</em>中增加的顺序来执行。当多个定义的路由都可能匹配同一个URL时也是如此，除非某个路由并不调用<em>next()</em>且已将响应输出到客户端，否则它们也将按顺序执行。</p>

<pre><code>
app.get('/users/:id?', function(req, res, next){
    var id = req.params.id;
    if (id) {
        // 一回注：如果在这里就将响应内容输出给客户端，那么后续的URL映射将不会被调用
    } else {
        next(); // 将控制转向下一个符合URL的路由
    }
});

app.get('/users', function(req, res){
    // do something else
});
</code></pre> 

		<p><em>app.all()</em>方法可以对所有HTTP动作应用单一调用入口，这在有些情况下很有用。下面我们使用该功能来从我们的模拟数据库中加载一个用户，并把它分配给<em>req.user</em>。</p>

<pre><code>
var express = require('express')
  , app = express.createServer();

var users = [{ name: 'www.csser.com' }];

app.all('/user/:id/:op?', function(req, res, next){
  req.user = users[req.params.id];
  if (req.user) {
    next();
  } else {
    next(new Error('cannot find user ' + req.params.id));
  }
});

app.get('/user/:id', function(req, res){
  res.send('viewing ' + req.user.name);
});

app.get('/user/:id/edit', function(req, res){
  res.send('editing ' + req.user.name);
});

app.put('/user/:id', function(req, res){
  res.send('updating ' + req.user.name);
});

app.get('*', function(req, res){
  res.send('what???', 404);
});

app.listen(3000);
</code></pre> 

		<h3 id="middleware">中间件</h3> 

		<p>中间件可以通过<a href="http://github.com/senchalabs/connect" target="_blank">Connect</a>传入<em>express.createServer()</em>，就像正常的连接服务器一样，比如：</p>

<pre><code>
var express = require('express');

var app = express.createServer(
    express.logger(),
    express.bodyParser()
);
</code></pre> 

		<p>另外，在<em>configure()</em>函数块中利用<em>use()</em>函数增加中间件，也是一种很好的方式。</p> 

<pre><code>app.use(express.logger({ format: ':method :uri' }));
</code></pre> 

		<p>通常连接中间件可以通过<em>require("connect")</em>的方式，如：</p> 

<pre><code>var connect = require('connect');
app.use(connect.logger());
app.use(connect.bodyParser());
</code></pre> 

		<p>这让人感觉有些不太爽，于是express重新输出了（re-exports)这些中间件属性，但是在使用上保持了<em>一致性</em>：</p> 

<pre><code>app.use(express.logger());
app.use(express.bodyParser());
</code></pre> 

		<h3 id="route-middleware">路由中间件</h3> 
		
		<p>这里路径映射也可以理解为路由的意思，路由通过传入一个或多个附加的回调函数（或数组）到方法中，从而可以利用特定路由的中间件。该功能对限制访问以及加载路由使用的数据非常有用。</p>

		<p>通常情况下异步数据的查询看起来像下面的样子，这里我们使用<em>:id</em>参数，并尝试获取一个用户。</p>

<pre><code>
app.get('/user/:id', function(req, res, next){
  loadUser(req.params.id, function(err, user){
    if (err) return next(err);
    res.send('Viewing user of csser.com ' + user.name);
  });
});
</code></pre> 

		<p>为了保持代码整洁并且提高可读性，我们可以在中间件内部应用该逻辑。正如你所看到的，将逻辑抽象到中间件里让我们达到一定程度的复用，同时代码更干净。</p> 

<pre><code>
function loadUser(req, res, next) {
  // 这里提供假数据，你可以从数据库中获取真实用户信息
  var user = users[req.params.id];
  if (user) {
    req.user = user;
    next();
  } else {
    next(new Error('不存在的用户 ' + req.params.id));
  }
}

app.get('/user/:id', loadUser, function(req, res){
  res.send('正在查看用户 ' + req.user.name);
});
</code></pre> 

		<p>一回注：看到了吗？上面的路径映射的回调函数参数是可以支持多个的。</p>

		<p>多重路由中间件可以被按照顺序来执行，从而可以实现更复杂的逻辑，比如限制访问某个用户的访问权限，下面的代码将只允许认证用户才可以编辑其帐号信息。</p>

<pre><code>
function andRestrictToSelf(req, res, next) {
  req.authenticatedUser.id == req.user.id
    ? next()
    : next(new Error('无权限'));
}

app.get('/user/:id/edit', loadUser, andRestrictToSelf, function(req, res){
  res.send('开始编辑用户 ' + req.user.name);
});
</code></pre> 

		<p>请记住中间件是简单的函数，我们还能定义<em>返回</em>中间件的函数，从而可以创建一个更有表现力和更易用的如下方案：</p> 

<pre><code>
function andRestrictTo(role) {
  return function(req, res, next) {
    req.authenticatedUser.role == role
      ? next()
      : next(new Error('无权限'));
  }
}

app.del('/user/:id', loadUser, andRestrictTo('admin'), function(req, res){
  res.send('已删除用户 ' + req.user.name);
});
</code></pre> 

		<p>一回注：app.del的第三个参数之所以可以这样写，是因为其返回的是一个函数，而该函数可以访问’admin’的值，这里涉及到闭包的概念，如有疑问请在CSSer.com查找闭包相关文章。</p>

		<p>通常使用的中间件的“栈”可以被作为数组（<em>递归应用</em>）传入，如此可以被混合并能匹配更复杂的功能。</p>

<pre><code>
var a = [middleware1, middleware2]
  , b = [middleware3, middleware4]
  , all = [a, b];

app.get('/foo', a, function(){});
app.get('/bar', a, function(){});

app.get('/', a, middleware3, middleware4, function(){});
app.get('/', a, b, function(){});
app.get('/', all, function(){});
</code></pre> 

		<p>可以去express源码仓库查看完整的<a href="http://github.com/visionmedia/express/blob/master/examples/route-middleware/app.js" target="_blank">路由中间件示例</a>。</p>

		<h3 id="http-methods">HTTP 方法</h3> 

		<p>在CSSer前面的文章中我们已经接触过<em>app.get()</em>多次了，同时Express也提供了对其它HTTP动作的封装，如<em>app.post()</em>, <em>app.del()</em>等。</p>

		<p>对于<em>POST</em>最常见的例子，就是当我们提交一个表单时，下面我们在HTML中将表单的method特性设置为“post”，然后需要在服务端定义对该表单提交的路由控制。</p>

<pre><code> &lt;form method="post" action="/"&gt;
   &lt;input type="text" name="user[name]" /&gt;
   &lt;input type="text" name="user[email]" /&gt;
   &lt;input type="submit" value="Submit" /&gt;
&lt;/form&gt;
</code></pre> 

		<p>默认情况下Express并不知道该如何处理该请求体，因此我们需要增加bodyParser中间件，用于分析<em>application/x-www-form-urlencoded</em>和<em>application/json</em>请求体，并把变量存入<em>req.body</em>。我们可以像下面的样子来“使用”中间件：</p>

<pre><code>app.use(express.bodyParser());
</code></pre> 

		<p>接下来下面的路由就可以访问<em>req.body.user</em>对象了，该对象包含客户端提交的<em>name</em>和<em>email</em>属性。</p> 

<pre><code>
app.post('/', function(req, res){
  console.log(req.body.user);
  res.redirect('back');
});
</code></pre> 

		<p>要在表单中使用<em>PUT</em>的HTTP方法，我们可以利用名为<em>_method</em>的隐藏表单域，它能改变HTTP方法。而在服务端，我们首先需要利用<em>methodOverride</em>中间件，把它放在<em>bodyParser</em>中间件下方，从而可以利用包含表单值的<em>req.body</em>。</p>

<pre><code>app.use(express.bodyParser());
app.use(express.methodOverride());
</code></pre> 

		<p>之所以需要这样做，是因为这些处理并不总是默认进行的，原因很简单，因为这些对Express的整体功能来说并不是必需的，依据应用的具体需求，你并不一定需要这些功能，如果客户端直接支持<em>PUT</em>和<em>DELETE</em>方法也可以被直接访问到，同时<em>methodOverride</em>为表单提供了强大的解决方案，下面我们展示下PUT的使用：</p>

<pre><code>&lt;form method="post" action="/"&gt;
    &lt;input type="hidden" name="_method" value="put" /&gt;
    &lt;input type="text" name="user[name]" /&gt;
    &lt;input type="text" name="user[email]" /&gt;
    &lt;input type="submit" value="Submit" /&gt;    
&lt;/form&gt;

app.put('/', function(){
    console.log(req.body.user);
    res.redirect('back');
});
</code></pre> 

		<h3 id="error-handling">错误处理</h3> 

		<p>Express提供了<em>app.error()</em>方法来接收路由或传入<em>next(err)</em>的异常，下面的示例为不同的页面提供专门的<em>NotFound</em>异常服务：</p>

<pre><code>
function NotFound(msg){
  this.name = 'NotFound in csser.com';
  Error.call(this, msg);
  Error.captureStackTrace(this, arguments.callee);
}

NotFound.prototype.__proto__ = Error.prototype;

app.get('/404', function(req, res){
  throw new NotFound;
});

app.get('/500', function(req, res){
  throw new Error('keyboard cat!');
});
</code></pre> 

		<p>像下面一样，我们可以多次调用<em>app.error()</em>，这里我们检查如果是<em>NotFound</em>实例就显示404页面，否则将其传入下一个错误处理。</p>

		<p>注意这些处理可以定义在任何地方，它们可以放在路由可以<em>listen()</em>之处。这也允许在<em>configure()</em>块内做定义，于是我们就可以以不同的基于环境的方式处理异常。</p>

<pre><code>
app.error(function(err, req, res, next){
    if (err instanceof NotFound) {
        res.render('404.jade');
    } else {
        next(err);
    }
});
</code></pre> 

		<p>下面的演示我们假设所有错误都为500错误，但你可以根据喜好选择。例如当node在处理文件系统调用时，就有可能接收到这样的错误对象，其<em>ENOENT</em>的<em>error.code</em>为“no such file or directory”，这时我们可以在错误处理函数中进行处理然后显示特定的页面给用户。</p>

<pre><code>
app.error(function(err, req, res){
   res.render('500.jade', { error: err });
});
</code></pre> 

		<p>我们的应用也可以利用Connect <em>errorHandler</em>中间件来汇报异常信息。例如我们想在“开发”环境输出异常到<em>stderr</em>：</p>

<pre><code>app.use(express.errorHandler({ dumpExceptions: true }));
</code></pre> 

		<p>同时在开发期间我们想用好看的HTML页面显示异常信息时，可以设置<em>showStack</em>的值为true：</p>

<pre><code>app.use(express.errorHandler({ showStack: true, dumpExceptions: true }));
</code></pre> 

		<p>如果请求头<em>Accept: application/json</em>，<em>errorHandler</em>中间件也能以<em>json</em>方式做出响应，这对依赖于客户端Javascript的应用开发很有益处。</p>

		<h3 id="route-param pre-conditions">路由参数预处理</h3> 

		<p>路由参数预处理通过隐式的数据处理，可以大幅提高应用代码的可读性和请求URL的验证。假如你经常性的从几个路由获取通用数据，如通过<em>/user/:id</em>加载用户信息，通常我们可能会这样做：</p>

<pre><code>
app.get('/user/:userId', function(req, res, next){
  User.get(req.params.userId, function(err, user){
    if (err) return next(err);
    res.send('user ' + user.name);
  });
});
</code></pre> 

		<p>利用预处理后参数可以被映射到回调函数，从而可以提供诸如验证、强制性改变值，甚至从数据库中加载数据等功能。下面我们将调用<em>app.param()</em>并传入我们希望映射到某个中间件的参数，可以看到我们接收了包含占位符（:userId）值的<em>id</em>参数。在这里可以与平常一样进行用户数据加载以及错误处理，并能简单的通过调用<em>next()</em>将控制权转向下一个预处理或路由（路径控制）。</p>

<pre><code>
app.param('userId', function(req, res, next, id){
  User.get(id, function(err, user){
    if (err) return next(err);
    if (!user) return next(new Error('failed to find user'));
    req.user = user;
    next();
  });
});
</code></pre> 

		<p>这样做，不仅向上面提到的可以大幅提高路由的可读性，还能在整个应用中共享该部分的逻辑实现，达到复用目的。</p> 

<pre><code>
app.get('/user/:userId', function(req, res){
  res.send('CSSer用户为 ' + req.user.name);
});
</code></pre> 

		<p>对于简单的情况如路由占位符验证和强迫改变值，只需要传入1个参数（支持1个参数），期间抛出的异常将自动传入<em>next(err)</em>。</p> 

<pre><code>app.param('number', function(n){ return parseInt(n, 10); });
</code></pre> 

		<p>也可以同时将回调函数应用到多个占位符，比如路由<em>/commits/:from-:to</em>来说，:from和:to都是数值类型，我们可以将它们定义为数组：</p> 

<pre><code>app.param(['from', 'to'], function(n){ return parseInt(n, 10); });
</code></pre> 

		<h3 id="view-rendering">视图渲染</h3> 

		<p>视图的文件名默认需遵循“&lt;name&gt;.&lt;engine&gt;”的形式，这里&lt;engine&gt;是要被加载的模块的名字。比如视图<em>layout.ejs</em>就是在告诉视图系统要<em>require("ejs")</em>，被加载的模块必须输出<em>exports.compile(str, options)</em>方法，并要返回一个函数来遵守Express的模板接口约定。我们也可以使用<em>app.register()</em>来映射模板引擎到其它文件扩展名，从而实现更灵活的模板引擎行为，如此一来就可以实现“csser.html”可以被ejs引擎所渲染。</p>

		<p>下面我们将用<a href="http://github.com/visionmedia/jade" target="_blank">Jade</a>引擎来渲染<em>index.html</em>，因为我们没有设置<em>layout:false</em>，<em>index.jade</em>渲染后的内容将被作为<em>body</em>本地变量传入<em>layout.jade</em>。</p>

<pre><code>app.get('/', function(req, res){
    res.render('index.jade', { title: 'CSSer, 关注Web前端技术！' });
});
</code></pre> 

		<p>新增的<em>view engine</em>设置可以指定默认模板引擎，如果我们想使用jade可以这样设置：</p>

<pre><code>app.set('view engine', 'jade');
</code></pre> 

		<p>于是我们就可以通过下面的方式：</p> 

<pre><code>res.render('index');
</code></pre> 

		<p>代替如下方式:</p> 

<pre><code>res.render('index.jade');
</code></pre> 

		<p>当<em>view engine</em>设置后，模板的扩展名就成了可选项，同时我们还可以混合匹配多模板引擎：</p>

<pre><code>res.render('another-page.ejs');
</code></pre> 

		<p>Express同时提供了视图选项(<em>view options</em>)设置，这些设置会在每次视图渲染后应用，比如你并不经常使用layouts，就可以这样设置：</p>

<pre><code>app.set('view options', {
    layout: false
});
</code></pre> 

		<p>如果需要，这些设置可以在后续的<em>res.render()</em>调用中被覆盖：</p> 

<pre><code>res.render('csser-view.ejs', { layout: true });
</code></pre> 

		<p>可以通过指定一个路径的方式来实现用自己的layout来代替系统默认的，比如如果我们将“<em>view engine</em>”设置为<em>jade</em>并且自定义了一个名为“<em>./views/mylayout.jade</em>”的layout，我们可以这样使用它：</p>

<pre><code>res.render('page', { layout: 'mylayout' });
</code></pre> 

		<p>否则必须指定扩展名：</p> 

<pre><code>res.render('page', { layout: 'mylayout.jade' });
</code></pre> 

		<p>这些路径也可以是绝对路径：</p> 

<pre><code>res.render('page', { layout: __dirname + '/../../mylayout.jade' });
</code></pre> 

		<p>这方面较好的例子就是自定义<em>ejs</em>模板的开始和关闭的标记：</p> 

<pre><code>app.set('view options', {
    open: '{{',
    close: '}}'
});
</code></pre> 

		<h3 id="view-partials">局部视图</h3> 

		<p>Express视图系统原生支持局部和集合视图，这称作微型视图，主要用于渲染一个文档片段。比如与其在视图中循环显示评论，不如使用局部集合（partial collection）：</p>

<pre><code>partial('comment', { collection: comments });
</code></pre> 

		<p>如果不需要其它选项或本地变量，我们可以省略对象而简单的传入评论数组，这和上面的示例是一样的：</p> 

<pre><code>partial('comment', comments);
</code></pre> 

		<p>当使用局部集合时，支持一些“魔术”本地变量：</p> 

		<ul> 
			<li><em>firstInCollection</em>  当为第一个对象时该值为true</li> 
			<li><em>indexInCollection</em>  集合中对象的索引值</li> 
			<li><em>lastInCollection</em>  当为最后一个对象时为true</li> 
			<li><em>collectionLength</em>  集合的长度</li> 
		</ul> 


		<p>传入（或生成）的本地变量优先，但传入父视图的本地变量在子视图仍有效。因此如果我们用<em>partial(‘blog/post’, post)</em>来渲染博客日志时，将生成<em>post</em>的本地变量，但调用本函数的视图拥有本地<em>用户</em>，它在<em>blog/post</em>视图依然有效。</p>

		<p>性能提示：当使用局部集合渲染100长度的数组就意味着需要渲染100次视图，对于简单的集合你可以将循环内联，而不要使用局部集合，这样可以减少系统开销。</p> 

		<h3 id="view-lookup">视图查找</h3> 

		<p>视图查找是相对于父视图进行的，比如我们有一个名为“<em>views/user/list.jade</em>”的页面视图，如果在该视图中调用<em>partial(‘edit’)</em>，视图系统将会尝试查找并加载“<em>views/user/edit.jade</em>”，而<em>partial(‘../messages’)</em>将加载“<em>views/messages.jade</em>”。</p>

		<p>视图系统还支持索引模板，这样你就可以使用一个同名的目录。比如，在一个路由中我们执行<em>res.render(‘users’)</em>，这将指向“<em>views/users.jade</em>”或者“<em>views/users/index.jade</em>”。</p>

		<p>当使用上面的索引视图时，我们可以通过<em>partial(‘users’)</em>从同名目录下引用“<em>views/users/index.jade</em>”，同时视图系统会尝试“<em>../users/index</em>”，这能减少我们调用<em>partial(‘index’)</em>的需要。</p>

		<h3 id="template-engines">模板引擎</h3> 

		<p>Express支持许多模板引擎，常用的有：</p> 

		<ul> 
			<li><a href="http://github.com/visionmedia/haml.js" target="_blank">Haml</a> haml 的实现</li> 
			<li><a href="http://jade-lang.com" target="_blank">Jade</a>  haml.js 接替者，同时也是Express的默认模板引擎</li> 
			<li><a href="http://github.com/visionmedia/ejs" target="_blank">EJS</a> 嵌入JavaScript模板</li> 
			<li><a href="http://github.com/mauricemach/coffeekup" target="_blank">CoffeeKup</a> 基于CoffeeScript的模板引擎</li> 
			<li><a href="https://github.com/kof/node-jqtpl" target="_blank">jQuery Templates</a> 的NodeJS版本</li> 
		</ul> 


		<h3 id="session-support">Session Support</h3> 

		<p>可以在Express中通过增加Connect的<em>session</em>中间件来开启Session支持，当然前提是需要在这之前使用<em>cookieParser</em>中间件，用于分析和处理<em>req.cookies</em>的cookie数据(我们知道session会利用cookie进行通信保持的)。</p>

<pre><code>app.use(express.cookieParser());
app.use(express.session({ secret: "keyboard cat" }));
</code></pre> 

		<p>默认<em>session</em>中间件使用Connect绑定的内存存储，但也有另外的实现方式。比如<a href="http://github.com/visionmedia/connect-redis" target="_blank">connect-redis</a>就提供了一个<a href="http://code.google.com/p/redis/" target="_blank">Redis</a>的session存储方案：</p>

<pre><code>var RedisStore = require('connect-redis');
app.use(express.cookieParser());
app.use(express.session({ secret: "CSSer加密字符串", store: new RedisStore }));
</code></pre> 

		<p>现在<em>req.session</em>和<em>req.sessionStore</em>属性就可以被所有路由及下级中间件所访问，<em>req.session</em>的属性会伴随着每一次响应发送给客户端，下面是一个购物车的例子：</p>

<pre><code>var RedisStore = require('connect-redis');
app.use(express.bodyParser());
app.use(express.cookieParser());
app.use(express.session({ secret: "keyboard cat", store: new RedisStore }));

app.post('/add-to-cart', function(req, res){
  // 利用bodyParser()中间件处理POST提交的表单数据
  var items = req.body.items;
  req.session.items = items;
  res.redirect('back');
});

app.get('/add-to-cart', function(req, res){
  // 当页面回到返回并通过GET请求/add-to-cart 时
  // 我们可以检查req.session.items && req.session.items.length，然后将信息打印到页面
  if (req.session.items && req.session.items.length) {
    req.flash('info', 'You have %s items in your cart', req.session.items.length);
  }
  res.render('shopping-cart');
});
</code></pre> 

		<p><em>req.session</em>对象还拥有许多其它方法，如<em>Session#touch()</em>, <em>Session#destroy()</em>, <em>Session#regenerate()</em>等用于session处理，更多信息请查看<a href="http://senchalabs.github.com/connect/middleware-session.html" target="_blank">Connect Session文档</a>。</p>
		
		<p>
			<br>相关链接： <a href="http://www.csser.com/tag/NodeJS,Express" target="_blank">CSSer的NodeJS和ExpressJS相关文章</a>
			<br>本手册可自由转载，但须注明译者及来源，尊重他人劳动，共建和谐的学习与研究氛围，从你我做起。 
		</p>

		</div> 
	</div> 
    <script type="text/javascript" src="../js/jquery-1.7.min.js"></script>
	<script type="text/javascript" src="../js/main.js"></script>
</body> 
</html>
